home *** CD-ROM | disk | FTP | other *** search
/ ftp.mactech.com 2010 / ftp.mactech.com.tar / ftp.mactech.com / machack / Hacks95 / Closure.sit / Closure / Sources / GX Graphics Libraries / font library.c next >
Text File  |  1995-06-24  |  20KB  |  508 lines
  1. /* graphics:    
  2.     gxFont library routines
  3.     by Cary Clark, Georgiann Delaney, Michael Fairman, Dave Good, Robert Johnson, Keith McGreggor, Mike Reed, Oliver Steele, David Van Brink, Chris Yerga
  4.     Copyright ©1987 - 1991 Apple Computer, Inc.  All rights reserved.
  5. */
  6.  
  7.     
  8. #ifndef powerc
  9.  #pragma pointers_in_D0                        
  10. #endif
  11.  
  12. #include <Memory.h>
  13. #include <Quickdraw.h>
  14. #include "font routines.h"
  15. #include "graphics toolbox.h"
  16.     
  17. #ifndef powerc
  18.  #pragma pointers_in_A0                            
  19. #endif
  20.  
  21. #include "font library.h"
  22. #include "graphics libraries.h"
  23.  
  24. #ifdef THINK_C
  25. #pragma options(signed_pstrs)   /* for Think C 5.0 */
  26. #endif
  27. #ifdef MacintoshIncludes
  28.     #define NewString gNewString
  29. #endif
  30.  
  31. typedef struct {
  32.     gxFont        fontID;
  33.     char*   fullName;
  34. } fontNameRecord;
  35.  
  36. static fontNameRecord commonLibraryFonts[] = {
  37.     { nil, "Chicago" },
  38.     { nil, "Courier" },
  39.     { nil, "Geneva" },
  40.     { nil, "Helvetica" },
  41.     { nil, "Monaco" },
  42.     { nil, "New York" },
  43.     { nil, "Symbol" },
  44.     { nil, "Times Roman" }
  45. };
  46.  
  47.  
  48. /***********************************
  49.  *  gxShape and gxStyle library routines to handle  fonts *
  50.  ***********************************/
  51.  
  52. gxFont GetCommonFont(commonFont fontIndex)
  53. {
  54.     if (fontIndex >= firstCommonFont && fontIndex <= lastCommonFont)
  55.     {   if (commonLibraryFonts[fontIndex].fontID == nil)
  56.             commonLibraryFonts[fontIndex].fontID = FindCNameFont(gxFullFontName, commonLibraryFonts[fontIndex].fullName);
  57.         return commonLibraryFonts[fontIndex].fontID;
  58.     }
  59.     return GXGetDefaultFont();
  60. }
  61.  
  62. void SetShapeCommonFont(gxShape s, commonFont fontIndex)
  63. {
  64.     GXSetShapeFont(s, GetCommonFont(fontIndex));
  65. }
  66.  
  67. void SetStyleCommonFont(gxStyle s, commonFont fontIndex)
  68. {
  69.     GXSetStyleFont(s, GetCommonFont(fontIndex));
  70. }
  71.  
  72. static long CLength(const char *name)
  73. {
  74.     const char *nameEnd = name;
  75.     
  76.     while ((*nameEnd++) != 0)
  77.         ;
  78.     return nameEnd - name - 1;
  79. }
  80.  
  81. gxFont FindCNameFont(gxFontName meaning, const char* name)
  82. {
  83.     gxFont fontID = nil;
  84.     GXFindFonts(0, meaning, gxMacintoshPlatform, gxRomanScript, gxEnglishLanguage, CLength(name), (unsigned char *) name, 1, 1, &fontID);
  85.     return fontID;
  86. }
  87.  
  88. gxFont FindPNameFont(gxFontName meaning, const unsigned char name[])
  89. {
  90.     gxFont fontID = nil;
  91.     GXFindFonts(0, meaning, gxMacintoshPlatform, gxRomanScript, gxEnglishLanguage, name[0], &name[1], 1, 1, &fontID);
  92.     return fontID;
  93. }
  94.  
  95. /************ gxFont names *************/
  96.  
  97. long FindFontCName(gxFont fontID, gxFontName meaning, char name[])
  98. {
  99.     long length = GXFindFontName(fontID, meaning, gxMacintoshPlatform, gxRomanScript, gxEnglishLanguage, (unsigned char*)name, nil);
  100.  
  101.     if (name)
  102.         name[length] = 0;
  103.     return length;
  104. }
  105.  
  106. long FindFontPName(gxFont fontID, gxFontName meaning, unsigned char name[])
  107. {
  108.     long length = GXFindFontName(fontID, meaning, gxMacintoshPlatform, gxRomanScript, gxEnglishLanguage, &name[1], nil);
  109.  
  110.     if (name)
  111.         name[0] = length;
  112.     return length;
  113. }
  114.  
  115. long FindStyleFontCName(gxStyle s, gxFontName meaning, char name[])
  116.  {
  117.     gxFont fontID = GXGetStyleFont(s);
  118.     return(FindFontCName(fontID, meaning, name));
  119.  }
  120.  
  121. long FindStyleFontPName(gxStyle s, gxFontName meaning, unsigned char name[])
  122.  {
  123.     gxFont fontID = GXGetStyleFont(s);
  124.     return(FindFontPName(fontID, meaning, name));
  125.  }
  126.  
  127. void SetStylePNamedFont(gxStyle s, const unsigned char name[])
  128. {
  129.     gxFont fontID = FindPNameFont(gxFullFontName, name);
  130.     if (fontID != GXGetStyleFont(s))
  131.         GXSetStyleFont(s, fontID);
  132. }
  133.  
  134. void SetStyleCNamedFont(gxStyle s, const char* name)
  135. {
  136.     gxFont fontID = FindCNameFont(gxFullFontName, name);
  137.     if (fontID != GXGetStyleFont(s))
  138.         GXSetStyleFont(s, fontID);
  139. }
  140.  
  141. /************************
  142.  *  Routines for using GXFindFonts
  143.  ************************/
  144.  
  145. long CountFontFamilies(void)
  146. {
  147.     return GXFindFonts(nil, gxFamilyFontName, 0, 0, 0, 0, nil, 1, gxSelectToEnd, nil);
  148. }
  149.  
  150. gxFont FindFontFamily(long index, gxFontPlatform platform, gxFontScript script, gxFontLanguage language,
  151.     long nameLength, const unsigned char *name)
  152. {
  153.     gxFont fontID = nil;
  154.     GXFindFonts(nil, gxFamilyFontName, platform, script, language, nameLength, name, index, 1, &fontID);
  155.     return fontID;
  156. }
  157.  
  158. long CountFontStyles(gxFont family)
  159. {
  160.     return GXFindFonts(family, 0, 0, 0, 0, 0, nil, 1, gxSelectToEnd, nil);
  161. }
  162.  
  163. static gxFont GetFontStyle(gxFont family, long index)
  164. {
  165.     gxFont fontID = nil;
  166.     GXFindFonts(family, 0, 0, 0, 0, 0, nil, index, 1, &fontID);
  167.     return fontID;
  168. }
  169.  
  170. gxFont FindFontStyle(gxFont family, long index, gxFontPlatform platform, gxFontScript script, gxFontLanguage language,
  171.     long nameLength, const unsigned char *name)
  172. {
  173.     gxFont fontID = nil;
  174.  
  175.     if (index)
  176.         GXFindFonts(family, 0, 0, 0, 0, 0, nil, index, 1, &fontID);
  177.     else
  178.         GXFindFonts(family, gxStyleFontName, platform, script, language, nameLength, name, index, 1, &fontID);
  179.     return fontID;
  180. }
  181.  
  182. /****************************
  183.         Style matching routines
  184.  ****************************/
  185.  
  186. typedef struct {
  187.     Fixed       minValue;
  188.     Fixed       defaultValue;
  189.     Fixed       maxValue;
  190. } descriptorRange;
  191.  
  192. typedef struct {
  193.     descriptorRange weight;
  194.     descriptorRange width;
  195.     descriptorRange slant;
  196. } fontMatchDescriptor;
  197.  
  198. typedef struct {
  199.     Fixed       weight;
  200.     Fixed       width;
  201.     Fixed       slant;
  202. } fontStyleCoord;
  203.  
  204. /*********************************************/
  205. /*              PrepareStyleForMatching                 */
  206. /*  this sets the styles gxFont variations to that of the current gxFont    */
  207. /*  we'll use this as a master and keep it to do our matching off of    */
  208. /*  if the gxStyle already has variations then we'll check to see if  */
  209. /*  the gxFont has axes, if not we'll nuke the variations and set new */
  210. /*  ones based upon the 'fdsc' information(GXFindFontDescriptor should*/
  211. /*  look at the fond header for old type fonts      ???         */
  212. /*********************************************/
  213. static void PrepareStyleForMatching(gxStyle aStyle)
  214. {
  215.     fontStyleCoord coord;
  216.     gxFont fontID = GXGetStyleFont(aStyle);
  217.     
  218.     coord.weight = fixed1;
  219.     coord.width = fixed1;
  220.     coord.slant = 0;
  221.  
  222.     GXFindFontDescriptor(fontID, weightVariationTag, &coord.weight);  
  223.     GXFindFontDescriptor(fontID, widthVariationTag, &coord.width);    
  224.     GXFindFontDescriptor(fontID, slantVariationTag, &coord.slant);    
  225.  
  226.     /* if (!( GXGetStyleFontVariations(aStyle, nil))) */
  227.     {   gxFontVariation* variations = (gxFontVariation*)NewPtr(3 * sizeof(gxFontVariation));
  228.         {   variations[0].name = weightVariationTag;    /*will actually check to see if current variations are set*/
  229.             variations[0].value = coord.weight; /*then we'll append any needed ones*/
  230.             variations[1].name = widthVariationTag; /*need a new routine that will set and create if needed*/
  231.             variations[1].value = coord.width;
  232.             variations[2].name = slantVariationTag;
  233.             variations[2].value = coord.slant;
  234.         }
  235.         GXSetStyleFontVariations(aStyle, 3, variations);
  236.         DisposePtr((Ptr)variations);
  237.     }
  238. }
  239.  
  240. /*
  241.  *  This builds a complete description of a gxFont as it is being used in a gxStyle.
  242.  *  Use this to compare against the styles in another gxFont family, to find the closest match.
  243.  */
  244. static void BuildFontStyleCoord(gxStyle aStyle, fontStyleCoord* coord)
  245. {
  246.     gxFont fontID = GXGetStyleFont(aStyle);
  247.     long i, count;
  248.     Fixed value;
  249.     gxFontTableTag aTag;
  250.  
  251.     coord->weight = fixed1;
  252.     coord->width = fixed1;
  253.     coord->slant = 0;
  254.  
  255.     GXFindFontDescriptor(fontID, weightVariationTag, &coord->weight); 
  256.     GXFindFontDescriptor(fontID, widthVariationTag, &coord->width);   
  257.     GXFindFontDescriptor(fontID, slantVariationTag, &coord->slant);   
  258.     
  259.     count = GXGetStyleFontVariations(aStyle, nil);
  260.     if (count)
  261.     {   gxFontVariation* variations = (gxFontVariation*)NewPtr(count * sizeof(gxFontVariation));
  262.         GXGetStyleFontVariations(aStyle, variations);
  263.         for (i = 0; i < count; i++)
  264.         {   aTag = variations[i].name;
  265.             value = variations[i].value;
  266.             if (aTag == weightVariationTag)
  267.                 coord->weight = value;
  268.             else if (aTag == widthVariationTag)
  269.                 coord->width = value;
  270.             else if (aTag == slantVariationTag)
  271.                 coord->slant = value;
  272.         }
  273.         DisposePtr((Ptr)variations);
  274.     }
  275. }
  276.  
  277. /*
  278.  *  This builds a complete description of a gxFont, giving its ranges for the various styles
  279.  *      weight, width, slant.
  280.  *  If the gxFont does not support a range for a given gxStyle, then min = max = default.
  281.  */
  282. static void BuildFontMatchDescriptor(gxFont fontID, fontMatchDescriptor* descriptor)
  283. {
  284.  
  285.     descriptor->weight.minValue = descriptor->weight.defaultValue = descriptor->weight.maxValue = 0;
  286.     descriptor->width.minValue = descriptor->width.defaultValue = descriptor->width.maxValue = 0;
  287.     descriptor->slant.minValue = descriptor->slant.defaultValue = descriptor->slant.maxValue = 0;
  288.  
  289.     if (GXFindFontDescriptor(fontID, weightVariationTag, &descriptor->weight.defaultValue))
  290.         descriptor->weight.minValue = descriptor->weight.maxValue = descriptor->weight.defaultValue;
  291.     if (GXFindFontDescriptor(fontID, widthVariationTag, &descriptor->width.defaultValue))
  292.         descriptor->width.minValue = descriptor->width.maxValue = descriptor->width.defaultValue;
  293.     if (GXFindFontDescriptor(fontID, slantVariationTag, &descriptor->slant.defaultValue))
  294.         descriptor->slant.minValue = descriptor->slant.maxValue = descriptor->slant.defaultValue;
  295.  
  296.     GXFindFontVariation(fontID, weightVariationTag, &descriptor->weight.minValue, &descriptor->weight.defaultValue, &descriptor->weight.maxValue, nil);
  297.     GXFindFontVariation(fontID, widthVariationTag, &descriptor->width.minValue, &descriptor->width.defaultValue, &descriptor->width.maxValue, nil);
  298.     GXFindFontVariation(fontID, slantVariationTag, &descriptor->slant.minValue, &descriptor->slant.defaultValue, &descriptor->slant.maxValue, nil);
  299. }
  300.  
  301. /*
  302.  *  This needs to scale each difference by some amount that balances the various styles
  303.  *      weight, width, slant
  304.  *  This could be a global table, or possible gxFont defined?
  305.  */
  306. static Fixed ComputeDescriptorMetric(fontStyleCoord* coord, fontMatchDescriptor* descriptor, fontStyleCoord* setting, fontStyleCoord* remaining)
  307. {
  308.     Fixed distance = 0;
  309.     fontStyleCoord remainBuffer;
  310.  
  311.     if (remaining == nil)
  312.         remaining = &remainBuffer;
  313.  
  314.     remaining->weight = remaining->width = remaining->slant = 0;
  315.                                                                 /*setting must fall within the range of descriptor min and max*/
  316.     setting->weight = (coord->weight < descriptor->weight.maxValue) ? coord->weight: descriptor->weight.maxValue;/* min of the maximums*/
  317.     setting->weight = (setting->weight > descriptor->weight.minValue) ? setting->weight: descriptor->weight.minValue;/* max of the minimums*/
  318.     remaining->weight = coord->weight - setting->weight;    /* if positive then we need to add more bolding with a textface, if negative we need to take some away*/
  319.     distance += (remaining->weight > 0) ? FixedMultiply(remaining->weight , prefwghtweighting): -FixedMultiply(remaining->weight , prefwghtweighting);/*absolute value for distance metric */
  320.     
  321.     setting->width = (coord->width < descriptor->width.maxValue) ? coord->width: descriptor->width.maxValue;/* min of the maximums*/
  322.     setting->width = (setting->width > descriptor->width.minValue) ? setting->width: descriptor->width.minValue;/* max of the minimums*/
  323.     remaining->width = coord->width - setting->width;   /* if positive then we need to extend via textface, if negative we need to condense*/
  324.     distance += (remaining->width > 0) ? FixedMultiply(remaining->width , prefwdthweighting): -FixedMultiply(remaining->width , prefwdthweighting);/*absolute value for distance metric  */
  325.  
  326.     setting->slant = (coord->slant < descriptor->slant.maxValue) ? coord->slant: descriptor->slant.maxValue;/* min of the maximums*/
  327.     setting->slant = (setting->slant > descriptor->slant.minValue) ? setting->slant: descriptor->slant.minValue;/* max of the minimums*/
  328.     remaining->slant = coord->slant - setting->slant;   /* if positive then we need to skew clockwise via textface, if negative we need to skew counter clockwise*/
  329.     /*actually, if there is any slant at all in the coord->slant then we don't want to make an italic gxFont more italic*/
  330.     distance += (remaining->slant > 0) ? FixedMultiply(remaining->slant, prefslntweighting): -FixedMultiply(remaining->slant, prefslntweighting);/*absolute value for distance metric  this is naturally weighted to be last pref*/
  331.     /* could use something like this and then weight it??? distance += FixedDivide(remaining->slant, ff(90) ); */
  332.     if(setting->slant)
  333.         remaining->slant = 0;
  334.  
  335.     return distance;
  336. }
  337.  
  338. static void AppendVariation(gxFontVariation** variation, gxFontTableTag aTag, Fixed value)
  339. {
  340.     gxFontVariation* var;
  341.     long size = GetHandleSize((Handle)variation);
  342.     
  343.     SetHandleSize((Handle)variation, size + sizeof(gxFontVariation));
  344.     var = (gxFontVariation*)((char*)*variation + size);
  345.     var->name = aTag;
  346.     var->value = value;
  347. }
  348.  
  349. static void CreateCoordVariations(fontStyleCoord* setting, fontMatchDescriptor* descriptor, gxFontVariation* variation)
  350. {
  351.     long count = 0;
  352.  
  353.     if (setting->weight != descriptor->weight.defaultValue)
  354.     {   variation[count].name = weightVariationTag;
  355.         variation[count].value = setting->weight;
  356.         count++;
  357.     }
  358.     if (setting->width != descriptor->width.defaultValue) count++;
  359.     {   variation[count].name = widthVariationTag;
  360.         variation[count].value = setting->width;
  361.         count++;
  362.     }
  363.     if (setting->slant != descriptor->slant.defaultValue) count++;
  364.     {   variation[count].name = slantVariationTag;
  365.         variation[count].value = setting->slant;
  366.         count++;
  367.     }
  368. }
  369.  
  370. /*  currently CreateCoordTextFace makes up the difference between the variation axes and the actual settings of the old gxStyle*/
  371. static gxTextFace* CreateCoordTextFace(fontStyleCoord* remainingCoord, fontMatchDescriptor* descriptor, fontStyleCoord* setting)
  372. {
  373.     #pragma unused(setting)
  374.     
  375.     gxTextFace* newFace;
  376.     Fixed newBoldAddition = 0;
  377.     
  378.     newFace = (gxTextFace*)NewPtr(sizeof(gxTextFace) +  (1 - gxAnyNumber) * sizeof(gxFaceLayer));
  379.     newFace->faceLayers = 1;
  380.     ResetMapping(&newFace->advanceMapping);
  381.  
  382.     newFace->faceLayer[0].outlineStyle = nil;
  383.     newFace->faceLayer[0].outlineFill = gxSolidFill;
  384.     newFace->faceLayer[0].flags = 0;
  385.     /*X=default length, Y = desired percentage bold, x = setting weight, y =new percentage bold to apply*/
  386.     /*  y = XY/x    */      /*newBoldAddition = FixedDivide( FixedMultiply(remainingCoord->weight, descriptor->weight.defaultValue), setting->weight);*/
  387.      if ( (remainingCoord->weight) && (descriptor->weight.defaultValue == fixed1) ) /*if there is bold left and the gxFont is not natuarally bold*/
  388.         /*newBoldAddition = FixedDivide( FixedMultiply(remainingCoord->weight, descriptor->weight.defaultValue), setting->weight);*/
  389.         newBoldAddition = fixed1/12;  /*this is just a temporary hack until textfaces are nailed down????*/
  390.     newBoldAddition *= (remainingCoord->weight > 0) ? 1: -1;    /*increase or decrease weight*/
  391.     newFace->faceLayer[0].boldOutset.x = newBoldAddition;   /*if negative this makes lighter???*/
  392.     newFace->faceLayer[0].boldOutset.y = 0;
  393.  
  394.     if (remainingCoord->width || remainingCoord->slant)
  395.     {   gxTransform curTransform = newFace->faceLayer[0].outlineTransform = GXNewTransform();
  396.         if (remainingCoord->width)
  397.         {   Fixed newWidthFactor = fixed1+ remainingCoord->width;
  398.             GXScaleTransform(curTransform, newWidthFactor, fixed1, 0, 0);
  399.         }
  400.         if (remainingCoord->slant)
  401.             GXSkewTransform(curTransform, -fixed1/4, 0, 0, 0);/*should do a slope from angle????*/
  402.     }
  403.     else
  404.         newFace->faceLayer[0].outlineTransform = nil;
  405.     return newFace;
  406. }
  407.  
  408. static gxFont FindMatchingFont(gxStyle currentStyle, gxFont targetFamily, gxFontVariation* newVariations, gxTextFace** newFace)
  409. {
  410.     Fixed bestMetric = ff(32767);
  411.     gxFont bestFont = targetFamily;
  412.     fontStyleCoord currentCoord, bestRemaining, bestSetting;
  413.     fontMatchDescriptor bestDesc;
  414.     long styleIndex, styleCount;
  415.  
  416.     BuildFontStyleCoord(currentStyle, ¤tCoord);   /*maybe take this out later??? use preparestyleformatching*/
  417.  
  418.     styleCount = CountFontStyles(targetFamily);
  419.     for (styleIndex = 1; styleIndex <= styleCount; styleIndex++)
  420.     {   Fixed metric;
  421.         gxFont targetFont = GetFontStyle(targetFamily, styleIndex);
  422.         fontStyleCoord remainingCoord, targetSetting;
  423.         fontMatchDescriptor targetDescriptor;
  424.  
  425.         BuildFontMatchDescriptor(targetFont, &targetDescriptor);
  426.         if(!GXGetFont(targetFont, nil, nil))
  427.             DebugStr((const unsigned char *)"\pError in FindMatchingFont with targetFont");
  428.         metric = ComputeDescriptorMetric(¤tCoord, &targetDescriptor, &targetSetting, &remainingCoord);
  429.         if (metric < bestMetric)
  430.         {   bestMetric = metric;
  431.             bestFont = targetFont;
  432.             bestDesc = targetDescriptor;
  433.             bestSetting = targetSetting;
  434.             bestRemaining = remainingCoord;
  435.         }
  436.     }
  437.     if (newVariations)  /*new way we won't have to do this?????*/
  438.         CreateCoordVariations(&bestSetting, &bestDesc, newVariations);
  439.     if (newFace)
  440.         *newFace = bestMetric ? CreateCoordTextFace(&bestRemaining, &bestDesc, &bestSetting) : nil;
  441.  
  442.     return bestFont;
  443. }
  444.  
  445. static void DisposeFaceParts(gxTextFace *newFace)
  446. {
  447.     long activeLayer = newFace->faceLayers - 1;
  448.  
  449.     do {
  450.         if (newFace->faceLayer[activeLayer].outlineStyle)
  451.             GXDisposeStyle(newFace->faceLayer[activeLayer].outlineStyle);
  452.         if (newFace->faceLayer[activeLayer].outlineTransform)
  453.             GXDisposeTransform(newFace->faceLayer[activeLayer].outlineTransform);
  454.     } while (--activeLayer >= 0);
  455.     DisposePtr((Ptr) newFace);
  456. }
  457.  
  458.  
  459. void SetMatchingStyle(gxFont targetFamily, gxStyle theStyle, long matchInfo)
  460. {
  461.     gxFont toFont;
  462.     gxTextFace *newFace = nil;
  463.     gxFontVariation newVariations[3];/*will only match on wght, wdth, slnt*/
  464.     gxFont fromFont = GXGetStyleFont(theStyle);
  465.     boolean toggle = false;
  466.     
  467.     if ( !( GXGetStyleFontVariations(theStyle, nil)) )
  468.         PrepareStyleForMatching(theStyle);
  469.     if(matchInfo & useTextFaceMatching)
  470.     {
  471.         if(matchInfo & useVariationsMatching)
  472.             toFont = FindMatchingFont(theStyle, targetFamily, newVariations, &newFace);
  473.         else
  474.             toFont = FindMatchingFont(theStyle, targetFamily, nil, &newFace);
  475.     }
  476.     if(!(matchInfo & useTextFaceMatching))
  477.     {
  478.         if(matchInfo & useVariationsMatching)
  479.             toFont = FindMatchingFont(theStyle, targetFamily, newVariations, nil);
  480.         else
  481.             toFont = FindMatchingFont(theStyle, targetFamily, nil, nil);
  482.     }
  483.  
  484.     
  485.     GXSetStyleFont(theStyle, toFont);
  486.     GXSetStyleFace(theStyle, nil);    /*remove any textfaces set  will have to do this selectively in the future???*/
  487.     
  488.     if(matchInfo & useVariationsMatching)
  489.     {   short varCount = GXCountFontVariations(toFont);
  490.     
  491.         if(varCount)
  492.             GXSetStyleFontVariations(theStyle, varCount, newVariations);
  493.     }
  494.     if(matchInfo & useTextFaceMatching)
  495.     {
  496.         if(newFace)
  497.             GXSetStyleFace(theStyle, newFace);
  498.     }   
  499.     if (newFace)
  500.         DisposeFaceParts(newFace);
  501. }
  502.  
  503. gxStyle ReturnMatchingStyle(gxFont targetFamily, gxStyle theStyle, long matchInfo)
  504. {   gxStyle aStyle = GXCopyToStyle(nil, theStyle);
  505.     SetMatchingStyle(targetFamily, aStyle, matchInfo);
  506.     return(aStyle);
  507. }
  508.